package com.lekang.system.service.impl;

import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.util.HashMap;
import java.util.Date;
import com.lekang.common.utils.DateUtils;
import com.lekang.common.utils.SecurityUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import com.lekang.system.mapper.CheckInManagementMapper;
import com.lekang.system.mapper.ElderlyMapper;
import com.lekang.system.mapper.FamilyMemberMapper;
import com.lekang.system.mapper.ContractMapper;
import com.lekang.system.mapper.BedMapper;
import com.lekang.system.mapper.SysUserRoleMapper;
import com.lekang.system.mapper.SysUserMapper;
import com.lekang.system.domain.CheckInManagement;
import com.lekang.system.domain.Elderly;
import com.lekang.system.domain.FamilyMember;
import com.lekang.system.domain.Contract;
import com.lekang.system.domain.Bed;
import com.lekang.system.domain.SysUserRole;
import com.lekang.common.core.domain.entity.SysUser;
import com.lekang.system.domain.dto.CheckInWorkflowDTO;
import com.lekang.system.service.ICheckInManagementService;
import com.lekang.system.service.IAccraditationRecordService;
import com.lekang.system.service.IPendingTasksService;
import com.lekang.system.service.ITodoTaskService;
import com.lekang.system.service.ISysUserService;
import com.lekang.system.domain.AccraditationRecord;
import com.lekang.system.domain.TodoTask;
import com.lekang.system.domain.PendingTasks;
import org.activiti.engine.RuntimeService;
import org.activiti.engine.TaskService;
import org.activiti.engine.task.Task;
import org.activiti.engine.runtime.ProcessInstance;

/**
 * 入住管理Service业务层处理
 * 
 * @author 刘卓
 * @date 2025-10-13
 */
@Service
public class CheckInManagementServiceImpl implements ICheckInManagementService 
{
    @Autowired
    private CheckInManagementMapper checkInManagementMapper;
    
    @Autowired
    private ElderlyMapper elderlyMapper;
    
    @Autowired
    private FamilyMemberMapper familyMemberMapper;
    
    @Autowired
    private ContractMapper contractMapper;
    
    @Autowired
    private BedMapper bedMapper;
    
    @Autowired
    private SysUserRoleMapper sysUserRoleMapper;
    
    @Autowired
    private SysUserMapper sysUserMapper;
    
    @Autowired
    private ITodoTaskService todoTaskService;
    
    // 工作流相关服务
    @Autowired
    private RuntimeService runtimeService;
    
    @Autowired
    private TaskService taskService;
    
    @Autowired
    private IAccraditationRecordService accraditationRecordService;
    
    @Autowired
    private IPendingTasksService pendingTasksService;
    
    @Autowired
    private ISysUserService userService;
    
    @Autowired
    private com.lekang.system.service.IBillService billService;

    /**
     * 查询入住管理
     * 
     * @param id 入住管理主键
     * @return 入住管理
     */
    @Override
    public CheckInManagement selectCheckInManagementById(Long id)
    {
        return checkInManagementMapper.selectCheckInManagementById(id);
    }

    /**
     * 查询入住管理列表
     * 
     * @param checkInManagement 入住管理
     * @return 入住管理
     */
    @Override
    public List<CheckInManagement> selectCheckInManagementList(CheckInManagement checkInManagement)
    {
        return checkInManagementMapper.selectCheckInManagementList(checkInManagement);
    }

    /**
     * 新增入住管理
     * 
     * @param checkInManagement 入住管理
     * @return 结果
     */
    @Override
    public int insertCheckInManagement(CheckInManagement checkInManagement)
    {
        checkInManagement.setCreateTime(DateUtils.getNowDate());
        return checkInManagementMapper.insertCheckInManagement(checkInManagement);
    }

    /**
     * 修改入住管理
     * 
     * @param checkInManagement 入住管理
     * @return 结果
     */
    @Override
    public int updateCheckInManagement(CheckInManagement checkInManagement)
    {
        return checkInManagementMapper.updateCheckInManagement(checkInManagement);
    }

    /**
     * 批量删除入住管理
     * 
     * @param ids 需要删除的入住管理主键
     * @return 结果
     */
    @Override
    public int deleteCheckInManagementByIds(Long[] ids)
    {
        return checkInManagementMapper.deleteCheckInManagementByIds(ids);
    }

    /**
     * 删除入住管理信息
     * 
     * @param id 入住管理主键
     * @return 结果
     */
    @Override
    public int deleteCheckInManagementById(Long id)
    {
        return checkInManagementMapper.deleteCheckInManagementById(id);
    }
    
    /**
     * 完整入住申请流程 - 多表事务插入
     * 同时插入：老人表、入住管理表、家人表、合同表、床表
     * 
     * @param dto 入住申请数据
     * @return 结果
     */
    @Transactional(rollbackFor = Exception.class)
    public Long completeCheckInApplication(CheckInWorkflowDTO dto) {
        try {
            System.out.println("开始处理入住申请，DTO: " + dto);
            
            // 1. 检查身份证号是否已存在
            Elderly existingElderly = elderlyMapper.selectElderlyByIdCard(dto.idCard);
            Long elderlyId;
            
            if (existingElderly != null) {
                // 身份证号已存在，使用现有老人信息
                elderlyId = existingElderly.getId();
                System.out.println("身份证号已存在，使用现有老人ID: " + elderlyId);
                
                // 更新现有老人的照片和身份证照片（如果提供了新的）
                if (dto.photo != null && !dto.photo.trim().isEmpty()) {
                    existingElderly.setPhoto(dto.photo);
                }
                if (dto.idCardFront != null && !dto.idCardFront.trim().isEmpty()) {
                    existingElderly.setIdCardFront(dto.idCardFront);
                }
                if (dto.idCardBack != null && !dto.idCardBack.trim().isEmpty()) {
                    existingElderly.setIdCardBack(dto.idCardBack);
                }
                if (dto.contact != null && !dto.contact.trim().isEmpty()) {
                    existingElderly.setContact(dto.contact);
                }
                if (dto.address != null && !dto.address.trim().isEmpty()) {
                    existingElderly.setAddress(dto.address);
                }
                
                // 更新字典字段（如果提供了新的）
                if (dto.gender != null && !dto.gender.trim().isEmpty()) {
                    existingElderly.setGender(dto.gender);
                }
                if (dto.birthDate != null) {
                    existingElderly.setBirthDate(dto.birthDate);
                }
                if (dto.age != null) {
                    existingElderly.setAge(dto.age);
                }
                if (dto.ethnicity != null) {
                    existingElderly.setEthnicity(dto.ethnicity);
                }
                if (dto.politicalStatus != null) {
                    existingElderly.setPoliticalStatus(dto.politicalStatus);
                }
                if (dto.religion != null) {
                    existingElderly.setReligion(dto.religion);
                }
                if (dto.maritalStatus != null) {
                    existingElderly.setMaritalStatus(dto.maritalStatus);
                }
                if (dto.education != null) {
                    existingElderly.setEducation(dto.education);
                }
                if (dto.incomeSource != null) {
                    existingElderly.setIncomeSource(dto.incomeSource);
                }
                if (dto.hobbies != null) {
                    existingElderly.setHobbies(dto.hobbies);
                }
                if (dto.medicalInsurance != null) {
                    existingElderly.setMedicalInsurance(dto.medicalInsurance);
                }
                if (dto.medicalCardNo != null && !dto.medicalCardNo.trim().isEmpty()) {
                    existingElderly.setMedicalCardNo(dto.medicalCardNo);
                }
                
                existingElderly.setUpdateTime(DateUtils.getNowDate());
                elderlyMapper.updateElderly(existingElderly);
                System.out.println("已更新现有老人信息");
            } else {
                // 身份证号不存在，插入新老人信息
                Elderly elderly = new Elderly();
                elderly.setName(dto.name);
                elderly.setIdCard(dto.idCard);
                elderly.setContact(dto.contact);
                elderly.setAddress(dto.address);
                elderly.setPhoto(dto.photo);
                elderly.setIdCardFront(dto.idCardFront);
                elderly.setIdCardBack(dto.idCardBack);
                
                // 设置字典字段
                elderly.setGender(dto.gender);
                elderly.setBirthDate(dto.birthDate);
                elderly.setAge(dto.age);
                elderly.setEthnicity(dto.ethnicity);
                elderly.setPoliticalStatus(dto.politicalStatus);
                elderly.setReligion(dto.religion);
                elderly.setMaritalStatus(dto.maritalStatus);
                elderly.setEducation(dto.education);
                elderly.setIncomeSource(dto.incomeSource);
                elderly.setHobbies(dto.hobbies);
                elderly.setMedicalInsurance(dto.medicalInsurance);
                elderly.setMedicalCardNo(dto.medicalCardNo);
                
                elderly.setCreateTime(DateUtils.getNowDate());
                elderly.setIsDeleted(0L);
                System.out.println("准备插入新老人信息: " + elderly);
                elderlyMapper.insertElderly(elderly);
                elderlyId = elderly.getId();
                System.out.println("新老人信息插入成功，ID: " + elderlyId);
            }
            
            // 2. 插入入住管理表（第一步：只保存基础信息，完整信息在签约时保存）
            CheckInManagement checkInManagement = new CheckInManagement();
            checkInManagement.setElderlyId(elderlyId);
            // 只保存老人ID和创建时间，其他字段在签约办理步骤保存
            checkInManagement.setCreateTime(DateUtils.getNowDate());
            // 保存评估草稿数据（JSON格式）
            checkInManagement.setAssessmentDraftJson(convertDtoToJson(dto));
            System.out.println("准备插入入住管理基础信息（草稿）: " + checkInManagement);
            checkInManagementMapper.insertCheckInManagement(checkInManagement);
            Long checkInManagementId = checkInManagement.getId();
            System.out.println("入住管理基础信息插入成功，ID: " + checkInManagementId);
            
            // 3. 🔥【关键修复】在第一步就保存家属信息，以便第二步评估时能够获取到
            if (dto.familyMembers != null && !dto.familyMembers.isEmpty()) {
                System.out.println("准备插入 " + dto.familyMembers.size() + " 条家属信息");
                for (CheckInWorkflowDTO.FamilyMemberDTO familyDto : dto.familyMembers) {
                    if (familyDto.name != null && !familyDto.name.trim().isEmpty()) {
                        FamilyMember familyMember = new FamilyMember();
                        familyMember.setName(familyDto.name);
                        familyMember.setContact(familyDto.contact);
                        familyMember.setRelationship(familyDto.relationship);
                        familyMember.setIdCard(familyDto.idCard);
                        familyMember.setAddress(familyDto.address);
                        familyMember.setIsEmergencyContact(familyDto.isEmergencyContact);
                        familyMember.setElderlyId(elderlyId);
                        familyMember.setCreateTime(DateUtils.getNowDate());
                        familyMember.setIsDeleted(0L);
                        familyMemberMapper.insertFamilyMember(familyMember);
                        System.out.println("第一步插入家属信息成功: " + familyMember.getName() + ", 关系: " + familyMember.getRelationship());
                    }
                }
            } else {
                System.out.println("⚠️ 没有家属信息需要保存");
            }
            
            // 注意：合同表、床位状态更新都在最后一步"签约办理"完成时才保存
            // 这里创建了入住申请的基础记录和家属信息
            
            System.out.println("所有数据插入完成，事务即将提交");
            return checkInManagementId; // 返回入住管理ID
        } catch (Exception e) {
            // 事务会自动回滚
            System.out.println("入住申请处理失败: " + e.getMessage());
            e.printStackTrace();
            throw new RuntimeException("入住申请处理失败: " + e.getMessage(), e);
        }
    }
    
    /**
     * 启动入住申请工作流
     * 参考请假工作流的实现方式
     * 
     * @param checkInManagementId 入住管理ID
     * @return 流程实例ID
     */
    @Transactional
    public String startCheckInWorkflow(Long checkInManagementId) {
        try {
            // 获取当前用户信息
            Long userId = SecurityUtils.getUserId();
            String username = SecurityUtils.getUsername();
            
            // 设置流程变量（审批人信息）
            Map<String, Object> variables = new HashMap<>();
            variables.put("assignee1", userId); // 养老顾问（申请入住）
            variables.put("assignee2", getNursingTeamLeaderId()); // 护理组部长（入住评估）
            variables.put("assignee3", getVicePresidentId()); // 副院长（入住审批）
            variables.put("assignee4", userId); // 养老顾问（入住配置）
            variables.put("assignee5", getLegalStaffId()); // 法务部员工（签约办理）
            
            System.out.println("🔍 工作流审批人配置: assignee1=" + userId + ", assignee2=" + getNursingTeamLeaderId() + 
                             ", assignee3=" + getVicePresidentId() + ", assignee4=" + userId + ", assignee5=" + getLegalStaffId());
            
            // 启动流程实例
            ProcessInstance processInstance = runtimeService.startProcessInstanceByKey(
                "checkin", 
                checkInManagementId.toString(), 
                variables
            );
            String processInstanceId = processInstance.getId();
            System.out.println("入住申请工作流启动成功，流程实例ID: " + processInstanceId);
            
            // 完成第一个任务（申请提交）- 参考请假工作流的实现
            // 使用 list() 代替 singleResult() 防止多任务异常
            List<Task> firstTasks = taskService.createTaskQuery()
                .processInstanceBusinessKey(checkInManagementId.toString())
                .processDefinitionKey("checkin")
                .taskAssignee(userId.toString())
                .list();
            
            Task task = null;
            if (firstTasks != null && !firstTasks.isEmpty()) {
                task = firstTasks.get(0);
                taskService.complete(task.getId());
                System.out.println("✅ 申请提交任务完成: " + task.getId() + " (查询到 " + firstTasks.size() + " 个任务)");
            } else {
                System.out.println("⚠️ 未找到待完成的第一步任务");
            }
            
            // 保存审批记录（首提记录，不带taskId）- 参考请假工作流
            AccraditationRecord record = new AccraditationRecord();
            record.setOpinion("同意");
            record.setType(3L); // 3:入住申请
            record.setFinishTime(new Date());
            record.setApproverId(userId);
            record.setApproverName(username);
            record.setApproverNameRole("申请人");
            record.setNextApproverId(getNursingTeamLeaderId()); // 护理组部长
            record.setNextApprover("护理组部长");
            record.setNextApproverRole("护理组部长");
            record.setBussniessId(checkInManagementId);
            record.setCurrentStep("发起申请-提交入住申请");
            record.setNextStep("审批-入住评估");
            record.setAuditStatus(1L); // 1:通过
            record.setStepNo(1L);
            record.setHandleType(1L); // 1:处理
            accraditationRecordService.insertAccraditationRecord(record);
            
            // 创建TodoTask记录 - 用于"我的代办"显示
            TodoTask todoTask = new TodoTask();
            todoTask.setTaskNo("RZ-" + checkInManagementId); // 入住申请编号
            todoTask.setTaskTitle("入住申请ID为:" + checkInManagementId + "的入住申请");
            todoTask.setTodoType("入住");
            todoTask.setApplicantId(userId);
            todoTask.setApplicantName(username);
            
            // 获取老人信息（selectCheckInManagementById已修复，移除了family_member的JOIN并加了LIMIT 1）
            CheckInManagement checkInManagement = checkInManagementMapper.selectCheckInManagementById(checkInManagementId);
            if (checkInManagement != null && checkInManagement.getElderlyId() != null) {
                Elderly elderly = elderlyMapper.selectElderlyById(checkInManagement.getElderlyId());
                if (elderly != null) {
                    todoTask.setElderlyId(elderly.getId());
                    todoTask.setElderlyName(elderly.getName());
                }
            }
            
            todoTask.setApplyTime(DateUtils.getNowDate());
            todoTask.setProcessStatus("申请中");
            todoTask.setCreateTime(DateUtils.getNowDate());
            todoTaskService.insertTodoTask(todoTask);
            
            // 🔥【关键修复】完成第一步后，查询当前活动任务（应该是第二步）
            // 使用 list() 获取所有活动任务，然后取第一个（防止 singleResult 抛出 TooManyResultsException）
            List<Task> activeTasks = taskService.createTaskQuery()
                .processInstanceBusinessKey(checkInManagementId.toString())
                .processDefinitionKey("checkin")
                .active() // 🔥 只查询活动任务（未完成的任务）
                .list();
            
            System.out.println("🔍 查询到的活动任务数量: " + (activeTasks != null ? activeTasks.size() : 0));
            if (activeTasks != null && !activeTasks.isEmpty()) {
                for (int i = 0; i < activeTasks.size(); i++) {
                    Task t = activeTasks.get(i);
                    System.out.println("  活动任务[" + i + "] - ID: " + t.getId() + ", 名称: " + t.getName());
                }
            }
            
            Task currentActiveTask = (activeTasks != null && !activeTasks.isEmpty()) ? activeTasks.get(0) : null;
            
            System.out.println("🔍 选择的当前活动任务: " + (currentActiveTask != null ? currentActiveTask.getName() + " (ID: " + currentActiveTask.getId() + ")" : "无"));
            
            // 🔥【串行流程】只创建第一步和第二步的待办任务
            // 第一步：入住申请（已完成）
            // 第二步：当前活动任务（待处理）
            // 后续步骤：在审批通过后动态创建
            String[] allTaskNames = {"入住申请", "入住评估", "入住审批", "入住配置", "签约办理"};
            
            // 创建第一步的待办任务（已完成）
            String firstTaskName = allTaskNames[0];
            Long firstAssigneeId = getNextAssigneeId(firstTaskName, checkInManagementId);
            String firstAssigneeName = getNextAssignee(firstTaskName);
            
            if (firstAssigneeId != null) {
                PendingTasks firstPt = new PendingTasks();
                firstPt.setBussniessId(checkInManagementId);
                firstPt.setTaskId(task != null ? task.getId() : null);
                firstPt.setTitle("入住申请ID为:" + checkInManagementId + "的" + firstTaskName);
                firstPt.setType(3L); // 3:入住申请
                firstPt.setAssignee(firstAssigneeName);
                firstPt.setAssigneeId(firstAssigneeId);
                firstPt.setStatus(2L); // 已完成
                firstPt.setIsHandle(1L); // 已处理
                firstPt.setFinishTime(new Date());
                firstPt.setApplicationTime(DateUtils.getNowDate());
                firstPt.setApplicat(username);
                firstPt.setApplicatId(userId);
                firstPt.setStepNo(1L);
                pendingTasksService.insertPendingTasks(firstPt);
                System.out.println("✅ 创建第1步待办任务（已完成）: " + firstTaskName);
            }
            
            // 创建第二步的待办任务（待处理）
            if (currentActiveTask != null) {
                String secondTaskName = currentActiveTask.getName();
                Long secondStepNo = getStepNumber(secondTaskName);
                Long secondAssigneeId = getNextAssigneeId(secondTaskName, checkInManagementId);
                String secondAssigneeName = getNextAssignee(secondTaskName);
                
                System.out.println("🔍 第二步任务创建 - 任务名称: " + secondTaskName + ", 步骤号: " + secondStepNo);
                System.out.println("🔍 第二步任务创建 - 审批人ID: " + secondAssigneeId + ", 审批人: " + secondAssigneeName);
                
                if (secondAssigneeId != null) {
                    PendingTasks secondPt = new PendingTasks();
                    secondPt.setBussniessId(checkInManagementId);
                    secondPt.setTaskId(currentActiveTask.getId());
                    secondPt.setTitle("入住申请ID为:" + checkInManagementId + "的" + secondTaskName);
                    secondPt.setType(3L); // 3:入住申请
                    secondPt.setAssignee(secondAssigneeName);
                    secondPt.setAssigneeId(secondAssigneeId);
                    secondPt.setStatus(1L); // 待处理
                    secondPt.setIsHandle(0L); // 未处理
                    secondPt.setApplicationTime(DateUtils.getNowDate());
                    secondPt.setApplicat(username);
                    secondPt.setApplicatId(userId);
                    secondPt.setStepNo(secondStepNo);
                    int insertResult = pendingTasksService.insertPendingTasks(secondPt);
                    
                    // 🔥【关键】保存创建好的第二步任务ID，用于验证
                    System.out.println("✅ 创建第" + secondStepNo + "步待办任务（待处理）: " + secondTaskName + " -> " + secondAssigneeName + " (插入结果: " + insertResult + ")");
                    System.out.println("🔍 第二步任务数据库ID: " + secondPt.getId());
                    System.out.println("🔍 第二步任务AssigneeID: " + secondPt.getAssigneeId());
                    System.out.println("🔍 第二步任务Assignee: " + secondPt.getAssignee());
                    System.out.println("🔍 第二步任务类型: " + secondPt.getType());
                    System.out.println("🔍 第二步任务状态: " + secondPt.getStatus());
                    System.out.println("🔍 第二步任务是否处理: " + secondPt.getIsHandle());
                } else {
                    System.err.println("❌ 获取第二步审批人ID失败，无法创建第二步待办任务！");
                }
            } else {
                System.err.println("❌ 查询不到当前活动任务，无法创建第二步待办任务！");
            }
            
            return processInstanceId;
            
        } catch (Exception e) {
            System.out.println("启动入住申请工作流失败: " + e.getMessage());
            e.printStackTrace();
            throw new RuntimeException("启动入住申请工作流失败: " + e.getMessage(), e);
        }
    }
    
    /**
     * 处理工作流任务
     * 
     * @param taskId 任务ID
     * @param opinion 审批意见
     * @param auditStatus 审批状态（1:通过，2:拒绝）
     * @param checkInManagementId 业务ID
     * @param stepNo 步骤号（前端传递）
     */
    @Transactional
    public void handleWorkflowTask(String taskId, String opinion, Long auditStatus, Long checkInManagementId, Long stepNo) {
        try {
            Long userId = SecurityUtils.getUserId();
            String username = SecurityUtils.getUsername();
            
            // 获取当前任务
            Task task = taskService.createTaskQuery().taskId(taskId).singleResult();
            if (task == null) {
                throw new RuntimeException("任务不存在");
            }
            
            // 完成任务
            Map<String, Object> variables = new HashMap<>();
            variables.put("approved", auditStatus == 1L);
            
            // 🔥【关键修复】传递所有assignee变量，防止流程定义中引用了未定义的变量
            // 某些Activiti版本或流程定义可能需要这些变量，即使当前节点不使用
            variables.put("assignee1", userId); // 养老顾问（申请入住）
            variables.put("assignee2", getNursingTeamLeaderId()); // 护理组部长（入住评估）
            variables.put("assignee3", getVicePresidentId()); // 副院长（入住审批）
            variables.put("assignee4", userId); // 养老顾问（入住配置）
            variables.put("assignee5", getLegalStaffId()); // 法务部员工（签约办理）
            variables.put("assignee6", userId); // 🔥 额外添加assignee6，防止某些场景需要
            
            System.out.println("🔍 完成任务，传递变量: " + variables.keySet());
            System.out.println("🔍 【审批前】当前任务ID: " + taskId + ", 任务名称: " + task.getName());
            
            // 完成当前任务 - Activiti会自动创建下一步任务
            taskService.complete(taskId, variables);
            System.out.println("✅ 任务已完成，Activiti应该已创建下一步任务");
            
            // 保存审批记录
            AccraditationRecord record = new AccraditationRecord();
            record.setOpinion(opinion);
            record.setType(3L); // 3:入住申请
            record.setFinishTime(new Date());
            record.setApproverId(userId);
            record.setApproverName(username);
            record.setApproverNameRole(getUserRole(task.getName()));
            record.setBussniessId(checkInManagementId);
            record.setCurrentStep(task.getName());
            record.setAuditStatus(auditStatus);
            record.setStepNo(stepNo); // ✅ 使用前端传递的stepNo
            record.setHandleType(1L);
            accraditationRecordService.insertAccraditationRecord(record);
            
            // 更新当前待办任务状态为已处理
            System.out.println("========== 开始更新当前步骤待办任务为已处理 ==========");
            PendingTasks queryTask = new PendingTasks();
            queryTask.setBussniessId(checkInManagementId);
            queryTask.setType(3L); // ⚠️ 关键修复：必须指定type=3（入住流程）
            queryTask.setStepNo(stepNo); // ✅ 使用前端传递的stepNo
            System.out.println("查询条件 - businessId: " + checkInManagementId + ", type: 3, stepNo: " + stepNo);
            
            List<PendingTasks> currentPendingTasks = pendingTasksService.selectPendingTasksList(queryTask);
            System.out.println("查询到的待办任务数量: " + (currentPendingTasks != null ? currentPendingTasks.size() : 0));
            
            if (currentPendingTasks != null && !currentPendingTasks.isEmpty()) {
                // 如果有多条记录，打印警告
                if (currentPendingTasks.size() > 1) {
                    System.err.println("【警告】找到多条待办任务记录(" + currentPendingTasks.size() + "条)，将更新所有记录");
                }
                
                // 更新所有匹配的待办任务（防止有重复记录）
                for (PendingTasks pendingTask : currentPendingTasks) {
                    System.out.println("更新前 - 待办ID: " + pendingTask.getId() + 
                                     ", 标题: " + pendingTask.getTitle() +
                                     ", 当前状态: " + pendingTask.getStatus() + 
                                     ", 当前是否处理: " + pendingTask.getIsHandle() +
                                     ", 当前taskId: " + pendingTask.getTaskId());
                    
                    pendingTask.setStatus(2L); // 2:已完成
                pendingTask.setIsHandle(1L); // 1:已处理
                    pendingTask.setFinishTime(new Date());
                    pendingTask.setTaskId(taskId); // 设置实际的taskId
                    
                    // ⚠️ 关键调试：打印设置后的值
                    System.out.println("【调试】设置后 - status: " + pendingTask.getStatus() + 
                                     ", isHandle: " + pendingTask.getIsHandle() +
                                     ", finishTime: " + pendingTask.getFinishTime() +
                                     ", taskId: " + pendingTask.getTaskId());
                    System.out.println("【调试】完整对象: " + pendingTask.toString());
                    
                    int updateCount = pendingTasksService.updatePendingTasks(pendingTask);
                    System.out.println("更新结果 - 待办ID: " + pendingTask.getId() + ", 影响行数: " + updateCount);
                    
                    // 验证更新后的状态
                    PendingTasks verifyTask = pendingTasksService.selectPendingTasksById(pendingTask.getId());
                    System.out.println("更新后验证 - 状态: " + verifyTask.getStatus() + 
                                     ", 是否处理: " + verifyTask.getIsHandle() +
                                     ", taskId: " + verifyTask.getTaskId());
                    
                    // 如果更新失败，记录错误
                    if (verifyTask.getStatus() == null || !verifyTask.getStatus().equals(2L) ||
                        verifyTask.getIsHandle() == null || !verifyTask.getIsHandle().equals(1L)) {
                        System.err.println("【严重错误】待办任务状态更新失败！");
                        System.err.println("  预期: status=2, isHandle=1");
                        System.err.println("  实际: status=" + verifyTask.getStatus() + ", isHandle=" + verifyTask.getIsHandle());
                        throw new RuntimeException("待办任务状态更新失败");
                    }
                }
                System.out.println("✓ 成功更新当前步骤待办任务为已处理: " + task.getName());
            } else {
                System.err.println("【警告】找不到当前步骤的待办任务记录！可能已被手动删除或数据不一致");
                System.err.println("  业务ID: " + checkInManagementId);
                System.err.println("  步骤号: " + getStepNumber(task.getName()));
                System.err.println("  任务名称: " + task.getName());
                // 🔥 不抛出异常，允许流程继续（可能是补救性操作）
                System.err.println("  ⚠️ 跳过当前步骤待办任务更新，继续处理下一步");
            }
            System.out.println("========== 当前步骤待办任务更新完成 ==========");
            
            // 如果审批通过，更新下一个节点的待办任务状态为待处理
            if (auditStatus == 1L) {
                System.out.println("========== 开始处理下一步待办任务 ==========");
                System.out.println("当前业务ID: " + checkInManagementId);
                System.out.println("已完成任务名称: " + task.getName());
                System.out.println("已完成步骤号: " + getStepNumber(task.getName()));
                
                // 🔥【关键修复】查询下一个活动任务 - 此时当前任务已完成，不会被查到
                List<Task> nextActiveTasks = taskService.createTaskQuery()
                    .processInstanceBusinessKey(checkInManagementId.toString())
                    .processDefinitionKey("checkin")
                    .active() // 只查询活动任务
                    .list();
                
                System.out.println("🔍 查询到的活动任务数量: " + (nextActiveTasks != null ? nextActiveTasks.size() : 0));
                if (nextActiveTasks != null && !nextActiveTasks.isEmpty()) {
                    for (int i = 0; i < nextActiveTasks.size(); i++) {
                        Task t = nextActiveTasks.get(i);
                        System.out.println("  【活动任务[" + i + "]】ID=" + t.getId() + 
                                         ", 名称=" + t.getName() + 
                                         ", 步骤号=" + getStepNumber(t.getName()));
                    }
                }
                
                Task nextTask = null;
                Long currentStepNo = getStepNumber(task.getName());
                
                // 🔥【关键修复】直接取第一个活动任务（因为当前任务已完成，剩下的就是下一步）
                if (nextActiveTasks != null && !nextActiveTasks.isEmpty()) {
                    // 优先找步骤号比当前大的任务
                    for (Task t : nextActiveTasks) {
                        Long taskStepNo = getStepNumber(t.getName());
                        if (taskStepNo != null && taskStepNo > currentStepNo) {
                            nextTask = t;
                            System.out.println("✅ 找到下一步任务: " + t.getName() + " (步骤号=" + taskStepNo + ", ID=" + t.getId() + ")");
                            break;
                        }
                    }
                    
                    // 如果没找到，可能是流程已结束
                    if (nextTask == null) {
                        System.out.println("⚠️  没有找到步骤号更大的任务，流程可能已结束或到达最后一步");
                    }
                } else {
                    System.out.println("⚠️  没有查询到活动任务，流程可能已结束");
                }
                
                if (nextTask != null) {
                    Long nextStepNo = getStepNumber(nextTask.getName());
                    System.out.println("下一步任务名称: " + nextTask.getName());
                    System.out.println("下一步步骤号: " + nextStepNo);
                    
                    // 更新下一个步骤的待办任务状态
                    PendingTasks nextQueryTask = new PendingTasks();
                    nextQueryTask.setBussniessId(checkInManagementId);
                    nextQueryTask.setType(3L); // ⚠️ 关键修复：必须指定type=3（入住流程）
                    nextQueryTask.setStepNo(nextStepNo);
                    List<PendingTasks> nextPendingTasks = pendingTasksService.selectPendingTasksList(nextQueryTask);
                    
                    System.out.println("查询到的下一步待办任务数量: " + (nextPendingTasks != null ? nextPendingTasks.size() : 0));
                    
                    if (nextPendingTasks != null && !nextPendingTasks.isEmpty()) {
                        // 所有步骤：都只有1个审批人，正常处理
                        PendingTasks nextPendingTask = nextPendingTasks.get(0);
                        System.out.println("更新前 - 待办ID: " + nextPendingTask.getId() + 
                                         ", 标题: " + nextPendingTask.getTitle() +
                                         ", 当前状态: " + nextPendingTask.getStatus() + 
                                         ", 当前是否处理: " + nextPendingTask.getIsHandle() +
                                         ", 当前taskId: " + nextPendingTask.getTaskId());
                        
                        // 【关键修复】使用独立的update对象，确保所有字段都被正确更新
                        PendingTasks updateTask = new PendingTasks();
                        updateTask.setId(nextPendingTask.getId()); // 必须设置ID作为更新条件
                        updateTask.setTaskId(nextTask.getId()); // 设置实际的taskId
                        updateTask.setStatus(1L); // 1:待处理 - 必须设置
                        updateTask.setIsHandle(0L); // 0:未处理 - 必须设置
                        
                        System.out.println("🔧 准备更新待办任务，参数如下：");
                        System.out.println("  - ID(更新条件): " + updateTask.getId());
                        System.out.println("  - taskId: " + updateTask.getTaskId());
                        System.out.println("  - status: " + updateTask.getStatus());
                        System.out.println("  - isHandle: " + updateTask.getIsHandle());
                        
                        // 🔥 新增：更新assignee信息（确保分配给正确的人）
                        // ⚠️ 注意：Activiti中getAssignee()返回的是用户ID的字符串形式，不是用户名
                        if (nextTask.getAssignee() != null) {
                            try {
                                Long assigneeUserId = Long.parseLong(nextTask.getAssignee());
                                
                                // 通过用户ID查询用户信息
                                SysUser assigneeUser = userService.selectUserById(assigneeUserId);
                                if (assigneeUser != null) {
                                    updateTask.setAssigneeId(assigneeUser.getUserId());
                                    updateTask.setAssignee(assigneeUser.getUserName());
                                    System.out.println("🔄 设置下一步处理人: " + assigneeUser.getUserName() + " (ID: " + assigneeUser.getUserId() + ")");
                    } else {
                                    System.err.println("⚠️ 未找到用户ID: " + assigneeUserId);
                                }
                            } catch (NumberFormatException e) {
                                // 如果解析失败，可能是用户名，尝试按用户名查询
                                String assigneeUsername = nextTask.getAssignee();
                                SysUser assigneeUser = userService.selectUserByUserName(assigneeUsername);
                                if (assigneeUser != null) {
                                    updateTask.setAssigneeId(assigneeUser.getUserId());
                                    updateTask.setAssignee(assigneeUser.getUserName());
                                    System.out.println("🔄 设置下一步处理人: " + assigneeUser.getUserName() + " (ID: " + assigneeUser.getUserId() + ")");
                                } else {
                                    System.err.println("⚠️ 未找到用户: " + assigneeUsername);
                                }
                            } catch (Exception e) {
                                System.err.println("❌ 查询assignee用户信息失败: " + e.getMessage());
                            }
                        }
                        
                        int updateCount = pendingTasksService.updatePendingTasks(updateTask);
                        System.out.println("更新结果: 影响行数=" + updateCount);
                        
                        // 验证更新后的状态
                        PendingTasks verifyTask = pendingTasksService.selectPendingTasksById(nextPendingTask.getId());
                        System.out.println("更新后 - 状态: " + verifyTask.getStatus() + 
                                         ", 是否处理: " + verifyTask.getIsHandle() +
                                         ", taskId: " + verifyTask.getTaskId());
                        
                        // 如果状态仍然不是1，记录错误
                        if (verifyTask.getStatus() == null || !verifyTask.getStatus().equals(1L)) {
                            System.err.println("【严重错误】下一步待办任务状态更新失败！预期status=1，实际status=" + verifyTask.getStatus());
                        }
                        
                        System.out.println("✓ 成功更新下一步待办任务为待处理: " + nextTask.getName() + " -> " + nextPendingTask.getAssignee());
                    } else {
                        System.err.println("【警告】找不到下一步的待办任务记录！将自动创建...");
                        System.err.println("  业务ID: " + checkInManagementId);
                        System.err.println("  步骤号: " + nextStepNo);
                        System.err.println("  任务名称: " + nextTask.getName());
                        
                        // 🔥【关键修复】找不到下一步待办任务时，自动创建
                        try {
                            PendingTasks newPendingTask = new PendingTasks();
                            newPendingTask.setBussniessId(checkInManagementId);
                            newPendingTask.setType(3L); // 3:入住申请
                            newPendingTask.setStepNo(nextStepNo);
                            newPendingTask.setTitle("入住申请ID为:" + checkInManagementId + "的" + nextTask.getName());
                            newPendingTask.setTaskId(nextTask.getId());
                            newPendingTask.setStatus(1L); // 1:待处理
                            newPendingTask.setIsHandle(0L); // 0:未处理
                            
                            // 🔥 从Activiti任务中获取审批人信息（优先级更高）
                            if (nextTask.getAssignee() != null) {
                                try {
                                    Long assigneeUserId = Long.parseLong(nextTask.getAssignee());
                                    SysUser assigneeUser = userService.selectUserById(assigneeUserId);
                                    if (assigneeUser != null) {
                                        newPendingTask.setAssigneeId(assigneeUser.getUserId());
                                        newPendingTask.setAssignee(assigneeUser.getUserName());
                                        System.out.println("🔄 从Activiti任务获取处理人: " + assigneeUser.getUserName() + " (ID: " + assigneeUser.getUserId() + ")");
                                    } else {
                                        // 如果找不到用户，回退到从任务名称推断
                                        newPendingTask.setAssigneeId(getAssigneeIdByTaskName(nextTask.getName()));
                                        newPendingTask.setAssignee(getAssigneeNameByTaskName(nextTask.getName()));
                                    }
                                } catch (NumberFormatException e) {
                                    // 如果解析失败，回退到从任务名称推断
                                    newPendingTask.setAssigneeId(getAssigneeIdByTaskName(nextTask.getName()));
                                    newPendingTask.setAssignee(getAssigneeNameByTaskName(nextTask.getName()));
                                }
                            } else {
                                // 如果Activiti任务没有assignee，从任务名称推断
                                newPendingTask.setAssigneeId(getAssigneeIdByTaskName(nextTask.getName()));
                                newPendingTask.setAssignee(getAssigneeNameByTaskName(nextTask.getName()));
                            }
                            
                            newPendingTask.setCreateTime(new Date());
                            
                            // 设置申请人信息（使用方法开头已定义的变量）
                            newPendingTask.setApplicatId(userId);
                            newPendingTask.setApplicat(username);
                            newPendingTask.setApplicationTime(new Date());
                            
                            int insertResult = pendingTasksService.insertPendingTasks(newPendingTask);
                            
                            if (insertResult > 0) {
                                System.out.println("✅ 成功创建下一步待办任务: " + nextTask.getName() + " (ID=" + newPendingTask.getId() + ")");
                            } else {
                                System.err.println("❌ 创建下一步待办任务失败！");
                            }
                        } catch (Exception createEx) {
                            System.err.println("❌ 创建下一步待办任务时发生异常: " + createEx.getMessage());
                            createEx.printStackTrace();
                        }
                    }
                } else {
                    System.out.println("流程结束，无需更新下一个待办任务");
                }
                System.out.println("========== 下一步待办任务处理完成 ==========");
            }
            
            // 如果审批通过且是最后一个节点，更新入住状态并同步数据
            if (auditStatus == 1L && "签约办理".equals(task.getName())) {
                System.out.println("========== 开始处理签约办理完成后的数据同步 ==========");
                
                // 1. 查询入住管理记录
                CheckInManagement checkIn = checkInManagementMapper.selectCheckInManagementById(checkInManagementId);
                if (checkIn != null) {
                    // 2. 查询对应的合同记录
                    Contract contractQuery = new Contract();
                    contractQuery.setCheckInManagementId(checkInManagementId);
                    List<Contract> contracts = contractMapper.selectContractList(contractQuery);
                    
                    if (contracts != null && !contracts.isEmpty()) {
                        Contract contract = contracts.get(0);
                        System.out.println("找到对应合同记录: " + contract.getContractNo());
                        
                        // 3. 同步合同数据到入住管理表
                        checkIn.setContractStatus("已入住");
                        checkIn.setCheckInNo(contract.getContractNo()); // 同步入住编号
                        checkIn.setCheckInStartTime(contract.getStartDate()); // 同步合同开始时间
                        checkIn.setCheckInEndTime(contract.getEndDate()); // 同步合同结束时间
                        
                        // 4. 从评估草稿JSON中提取护理等级信息
                        String assessmentJson = checkIn.getAssessmentDraftJson();
                        if (assessmentJson != null && !assessmentJson.isEmpty()) {
                            try {
                                // 解析JSON获取护理等级ID
                                if (assessmentJson.contains("\"nursingLevelId\":")) {
                                    String nursingLevelIdStr = assessmentJson.substring(
                                        assessmentJson.indexOf("\"nursingLevelId\":") + 17,
                                        assessmentJson.indexOf(",", assessmentJson.indexOf("\"nursingLevelId\":"))
                                    ).trim();
                                    if (!"null".equals(nursingLevelIdStr)) {
                                        Long nursingLevelId = Long.parseLong(nursingLevelIdStr);
                                        checkIn.setNursingLevelId(nursingLevelId);
                                        System.out.println("同步护理等级ID: " + nursingLevelId);
                                    }
                                }
                                
                                // 解析JSON获取床位ID
                                if (assessmentJson.contains("\"bedId\":")) {
                                    String bedIdStr = assessmentJson.substring(
                                        assessmentJson.indexOf("\"bedId\":") + 8,
                                        assessmentJson.indexOf(",", assessmentJson.indexOf("\"bedId\":"))
                                    ).trim();
                                    if (!"null".equals(bedIdStr)) {
                                        Long bedId = Long.parseLong(bedIdStr);
                                        checkIn.setBedId(bedId);
                                        System.out.println("同步床位ID: " + bedId);
                                    }
                                }
                            } catch (Exception e) {
                                System.err.println("解析评估草稿JSON失败: " + e.getMessage());
                            }
                        }
                        
                        // 5. 更新入住管理表
                        checkInManagementMapper.updateCheckInManagement(checkIn);
                        System.out.println("✅ 入住管理表数据同步完成");
                        System.out.println("  - 入住编号: " + checkIn.getCheckInNo());
                        System.out.println("  - 合同开始时间: " + checkIn.getCheckInStartTime());
                        System.out.println("  - 合同结束时间: " + checkIn.getCheckInEndTime());
                        System.out.println("  - 护理等级ID: " + checkIn.getNursingLevelId());
                        System.out.println("  - 床位ID: " + checkIn.getBedId());
                    } else {
                        System.err.println("⚠️ 未找到对应的合同记录，无法同步数据");
                        // 即使没有合同记录，也要更新状态
                        checkIn.setContractStatus("已入住");
                        checkInManagementMapper.updateCheckInManagement(checkIn);
                    }
                } else {
                    System.err.println("⚠️ 未找到入住管理记录，无法同步数据");
                }
                
                System.out.println("========== 签约办理完成后的数据同步处理完成 ==========");
            }
            
        } catch (Exception e) {
            throw new RuntimeException("处理工作流任务失败: " + e.getMessage(), e);
        }
    }
    
    /**
     * 根据任务名称获取用户角色
     */
    private String getUserRole(String taskName) {
        // 去除可能的空格
        if (taskName != null) {
            taskName = taskName.trim();
        }
        
        switch (taskName) {
            case "入住申请": return getElderlyAdvisorName(); // 返回实际用户名
            case "入住评估": return getNursingTeamLeaderName(); // 返回实际用户名
            case "入住审批": return getVicePresidentName(); // 返回实际用户名
            case "入住配置": return getElderlyAdvisorName(); // 返回实际用户名
            case "签约办理": return getLegalStaffName(); // 返回实际用户名
            default:
                System.out.println("警告：未知任务名称获取用户角色: [" + taskName + "]");
                return "未知角色";
        }
    }
    
    /**
     * 根据任务名称获取步骤号
     */
    private Long getStepNumber(String taskName) {
        // 去除可能的空格
        if (taskName != null) {
            taskName = taskName.trim();
        }
        
        switch (taskName) {
            // 新版流程（文件系统中的BPMN）- 5步流程
            case "入住申请": return 1L;
            case "入住评估": return 2L;
            case "入住审批": return 3L;
            case "入住配置": return 4L;
            case "签约办理": return 5L;
            
            // 旧版流程（数据库中已部署的流程）
            case "养老顾问提交": return 1L;
            case "护理员评估": return 2L;
            case "财务审核": return 3L;
            case "主任审批": return 4L;
            case "护理员配置": return 5L;
            
            default:
                System.out.println("警告：未知任务名称获取步骤号: [" + taskName + "], 使用默认值2");
                // 如果不知道是什么任务，默认返回2（第一个审核步骤）
                return 2L;
        }
    }
    
    /**
     * 根据任务名称获取该任务的审批人（当前任务执行人）
     */
    private String getNextAssignee(String taskName) {
        // 去除可能的空格
        if (taskName != null) {
            taskName = taskName.trim();
        }
        
        switch (taskName) {
            case "入住申请": return getElderlyAdvisorName(); // 养老顾问
            case "入住评估": return getNursingTeamLeaderName(); // 护理员组长
            case "入住审批": return getVicePresidentName(); // 副院长
            case "入住配置": return getElderlyAdvisorName(); // 养老顾问（回到申请人）
            case "签约办理": return getLegalStaffName(); // 法务部员工
            default:
                System.out.println("警告：未知任务名称获取审批人: [" + taskName + "], 使用默认值：护理组部长");
                // 默认返回第一个审核人：护理组部长
                return getNursingTeamLeaderName();
        }
    }
    
    /**
     * 根据任务名称获取该任务的审批人ID（当前任务执行人ID）
     */
    private Long getNextAssigneeId(String taskName, Long checkInManagementId) {
        // 去除可能的空格
        if (taskName != null) {
            taskName = taskName.trim();
        }
        
        switch (taskName) {
            case "入住申请": return getElderlyAdvisorId(); // 养老顾问
            case "入住评估": return getNursingTeamLeaderId(); // 护理员组长
            case "入住审批": return getVicePresidentId(); // 副院长
            case "入住配置": return getOriginalApplicantId(checkInManagementId); // 养老顾问（回到申请人）
            case "签约办理": return getLegalStaffId(); // 法务部员工
            default:
                System.out.println("警告：未知任务名称获取审批人ID: [" + taskName + "], 使用默认值：护理组部长ID");
                // 默认返回第一个审核人：护理组部长
                return getNursingTeamLeaderId();
        }
    }
    
    /**
     * 获取养老顾问用户ID
     * 角色配置：入住养老顾问 role_id=103, user_id=102 (liuzhuo)
     */
    private Long getElderlyAdvisorId() {
        try {
            // 角色ID 103: 入住养老顾问
            List<SysUserRole> userRoles = sysUserRoleMapper.getByRoleId(103L);
            if (userRoles != null && !userRoles.isEmpty()) {
                Long userId = userRoles.get(0).getUserId();
                System.out.println("获取养老顾问用户ID: " + userId);
                return userId;
            }
        } catch (Exception e) {
            System.out.println("获取养老顾问用户ID失败: " + e.getMessage());
        }
        System.out.println("警告：未找到养老顾问，使用默认值102");
        return 102L; // 默认值：liuzhuo
    }
    
    /**
     * 获取护理组部长用户ID
     * 角色配置：入住护理员组长 role_id=104, user_id=103 (zihao)
     */
    private Long getNursingTeamLeaderId() {
        try {
            // 角色ID 104: 入住护理员组长
            List<SysUserRole> userRoles = sysUserRoleMapper.getByRoleId(104L);
            if (userRoles != null && !userRoles.isEmpty()) {
                Long userId = userRoles.get(0).getUserId();
                System.out.println("获取护理员组长用户ID: " + userId);
                return userId;
            }
        } catch (Exception e) {
            System.out.println("获取护理员组长用户ID失败: " + e.getMessage());
        }
        System.out.println("警告：未找到护理员组长，使用默认值103");
        return 103L; // 默认值：zihao
    }
    
    /**
     * 获取护理主管用户ID（第二步第二个审批人）
     * 注意：role_id=106是"入住养老顾问"，不是护理主管
     * 如果需要护理主管角色，需要在数据库中单独创建
     */
    private Long getNursingSupervisorId() {
        try {
            // TODO: 需要在数据库中创建"入住护理主管"角色（如role_id=108）
            // 目前暂时返回护理组部长的ID
            System.out.println("警告：护理主管角色未配置，使用护理组部长代替");
            return getNursingTeamLeaderId();
        } catch (Exception e) {
            System.out.println("获取护理主管用户ID失败: " + e.getMessage());
        }
        System.out.println("警告：未找到护理主管，使用默认值103（与护理组部长相同）");
        return 103L; // 默认值：暂时使用护理组部长的ID
    }
    
    /**
     * 获取副院长用户ID
     * 角色配置：入住副院长 role_id=105, user_id=104 (chihao)
     */
    private Long getVicePresidentId() {
        try {
            // 角色ID 105: 入住副院长
            List<SysUserRole> userRoles = sysUserRoleMapper.getByRoleId(105L);
            if (userRoles != null && !userRoles.isEmpty()) {
                Long userId = userRoles.get(0).getUserId();
                System.out.println("获取副院长用户ID: " + userId);
                return userId;
            }
        } catch (Exception e) {
            System.out.println("获取副院长用户ID失败: " + e.getMessage());
        }
        System.out.println("警告：未找到副院长，使用默认值104");
        return 104L; // 默认值：chihao
    }
    
    /**
     * 获取法务部员工用户ID
     * 角色配置：入住法务部员工 role_id=107, user_id=105 (zhihao)
     */
    private Long getLegalStaffId() {
        try {
            // 角色ID 107: 入住法务部员工
            List<SysUserRole> userRoles = sysUserRoleMapper.getByRoleId(107L);
            if (userRoles != null && !userRoles.isEmpty()) {
                Long userId = userRoles.get(0).getUserId();
                System.out.println("获取法务部员工用户ID: " + userId);
                return userId;
            }
        } catch (Exception e) {
            System.out.println("获取法务部员工用户ID失败: " + e.getMessage());
        }
        System.out.println("警告：未找到法务部员工，使用默认值105");
        return 105L; // 默认值：zhihao
    }
    
    /**
     * 获取医疗主管用户ID（如果流程中有医疗评估步骤）
     * 角色配置：入住医疗主管 role_id=108, user_id待定
     */
    private Long getMedicalDirectorId() {
        try {
            // 角色ID 108: 入住医疗主管
            List<SysUserRole> userRoles = sysUserRoleMapper.getByRoleId(108L);
            if (userRoles != null && !userRoles.isEmpty()) {
                Long userId = userRoles.get(0).getUserId();
                System.out.println("获取医疗主管用户ID: " + userId);
                return userId;
            }
        } catch (Exception e) {
            System.out.println("获取医疗主管用户ID失败: " + e.getMessage());
        }
        System.out.println("警告：未找到医疗主管，使用默认值104（副院长）");
        return 104L; // 默认值：暂时使用副院长的ID
    }
    
    /**
     * 根据任务名称获取对应的审批人ID
     */
    private Long getAssigneeIdByTaskName(String taskName) {
        if (taskName == null) {
            return 1L;
        }
        
        switch (taskName.trim()) {
            case "入住申请":
                return getElderlyAdvisorId();
            case "入住评估":
                return getNursingTeamLeaderId();
            case "入住审批":
                return getVicePresidentId();
            case "入住配置":
                return getElderlyAdvisorId();
            case "签约办理":
                return getLegalStaffId();
            default:
                System.err.println("【警告】未知的任务名称: " + taskName + ", 使用默认审批人ID");
                return 1L;
        }
    }
    
    /**
     * 根据任务名称获取审批人姓名
     */
    private String getAssigneeNameByTaskName(String taskName) {
        if (taskName == null) {
            return "管理员";
        }
        
        switch (taskName.trim()) {
            case "入住申请":
                return getElderlyAdvisorName();
            case "入住评估":
                return getNursingTeamLeaderName();
            case "入住审批":
                return getVicePresidentName();
            case "入住配置":
                return getElderlyAdvisorName();
            case "签约办理":
                return getLegalStaffName();
            default:
                System.err.println("【警告】未知的任务名称: " + taskName + ", 使用默认审批人姓名");
                return "管理员";
        }
    }
    
    /**
     * 获取原始申请人ID（养老顾问）
     */
    private Long getOriginalApplicantId(Long checkInManagementId) {
        try {
            // 从入住申请记录中获取申请人ID
            CheckInManagement checkIn = checkInManagementMapper.selectCheckInManagementById(checkInManagementId);
            if (checkIn != null && checkIn.getCreateBy() != null) {
                return Long.parseLong(checkIn.getCreateBy());
            }
            
            // 如果无法从入住申请记录获取，从第一个待办任务中获取申请人ID
            PendingTasks queryTask = new PendingTasks();
            queryTask.setBussniessId(checkInManagementId);
            queryTask.setType(3L); // ⚠️ 关键修复：入住流程，type=3
            queryTask.setStepNo(1L); // 第一步
            List<PendingTasks> pendingTasks = pendingTasksService.selectPendingTasksList(queryTask);
            if (!pendingTasks.isEmpty()) {
                return pendingTasks.get(0).getApplicatId();
            }
        } catch (Exception e) {
            System.out.println("获取原始申请人ID失败: " + e.getMessage());
        }
        return 1L; // 默认值
    }
    
    /**
     * 获取养老顾问用户名
     */
    private String getElderlyAdvisorName() {
        try {
            // 角色ID 103: 入住养老顾问
            List<SysUserRole> userRoles = sysUserRoleMapper.getByRoleId(103L);
            if (userRoles != null && !userRoles.isEmpty()) {
                Long userId = userRoles.get(0).getUserId();
                SysUser user = sysUserMapper.selectUserById(userId);
                return user != null ? user.getUserName() : "养老顾问";
            }
        } catch (Exception e) {
            System.out.println("获取养老顾问用户名失败: " + e.getMessage());
        }
        return "养老顾问";
    }
    
    /**
     * 获取护理组部长用户名
     */
    private String getNursingTeamLeaderName() {
        try {
            // 角色ID 104: 入住护理员组长
            List<SysUserRole> userRoles = sysUserRoleMapper.getByRoleId(104L);
            if (userRoles != null && !userRoles.isEmpty()) {
                Long userId = userRoles.get(0).getUserId();
                SysUser user = sysUserMapper.selectUserById(userId);
                return user != null ? user.getUserName() : "护理员组长";
            }
        } catch (Exception e) {
            System.out.println("获取护理员组长用户名失败: " + e.getMessage());
        }
        return "护理员组长";
    }
    
    /**
     * 获取护理主管用户名（第二步第二个审批人）
     */
    private String getNursingSupervisorName() {
        try {
            // 角色ID 106: 入住护理主管
            List<SysUserRole> userRoles = sysUserRoleMapper.getByRoleId(106L);
            if (userRoles != null && !userRoles.isEmpty()) {
                Long userId = userRoles.get(0).getUserId();
                SysUser user = sysUserMapper.selectUserById(userId);
                return user != null ? user.getUserName() : "护理主管";
            }
        } catch (Exception e) {
            System.out.println("获取护理主管用户名失败: " + e.getMessage());
        }
        return "护理主管";
    }
    
    /**
     * 获取副院长用户名
     */
    private String getVicePresidentName() {
        try {
            List<SysUserRole> userRoles = sysUserRoleMapper.getByRoleId(105L);
            if (userRoles != null && !userRoles.isEmpty()) {
                Long userId = userRoles.get(0).getUserId();
                SysUser user = sysUserMapper.selectUserById(userId);
                return user != null ? user.getUserName() : "副院长";
            }
        } catch (Exception e) {
            System.out.println("获取副院长用户名失败: " + e.getMessage());
        }
        return "副院长";
    }
    
    /**
     * 获取法务部员工用户名
     */
    private String getLegalStaffName() {
        try {
            List<SysUserRole> userRoles = sysUserRoleMapper.getByRoleId(107L);
            if (userRoles != null && !userRoles.isEmpty()) {
                Long userId = userRoles.get(0).getUserId();
                SysUser user = sysUserMapper.selectUserById(userId);
                return user != null ? user.getUserName() : "法务部员工";
            }
        } catch (Exception e) {
            System.out.println("获取法务部员工用户名失败: " + e.getMessage());
        }
        return "法务部员工";
    }
    
    /**
     * 获取医疗主管用户名（如果流程中有医疗评估步骤）
     */
    private String getMedicalDirectorName() {
        try {
            List<SysUserRole> userRoles = sysUserRoleMapper.getByRoleId(108L);
            if (userRoles != null && !userRoles.isEmpty()) {
                Long userId = userRoles.get(0).getUserId();
                SysUser user = sysUserMapper.selectUserById(userId);
                return user != null ? user.getUserName() : "医疗主管";
            }
        } catch (Exception e) {
            System.out.println("获取医疗主管用户名失败: " + e.getMessage());
        }
        return "医疗主管";
    }
    
    /**
     * 获取原始申请人用户名
     */
    private String getOriginalApplicantName() {
        try {
            String currentUser = SecurityUtils.getUsername();
            return currentUser != null ? currentUser : "申请人";
        } catch (Exception e) {
            System.out.println("获取原始申请人用户名失败: " + e.getMessage());
        }
        return "申请人";
    }
    
    /**
     * 将DTO转换为JSON字符串（用于保存草稿）
     */
    private String convertDtoToJson(CheckInWorkflowDTO dto) {
        try {
            // 使用简单的JSON拼接（如果有Jackson可以使用ObjectMapper）
            StringBuilder json = new StringBuilder("{");
            json.append("\"contractNo\":\"").append(dto.contractNo != null ? dto.contractNo : "").append("\",");
            json.append("\"contractName\":\"").append(dto.contractName != null ? dto.contractName : "").append("\",");
            json.append("\"bedId\":").append(dto.bedId != null ? dto.bedId : "null").append(",");
            json.append("\"nursingLevelId\":").append(dto.nursingLevelId != null ? dto.nursingLevelId : "null").append(",");
            json.append("\"checkInStartTime\":\"").append(dto.checkInStartTime != null ? dto.checkInStartTime : "").append("\",");
            json.append("\"checkInEndTime\":\"").append(dto.checkInEndTime != null ? dto.checkInEndTime : "").append("\",");
            json.append("\"feeStartDate\":\"").append(dto.feeStartDate != null ? dto.feeStartDate : "").append("\",");
            json.append("\"feeEndDate\":\"").append(dto.feeEndDate != null ? dto.feeEndDate : "").append("\",");
            json.append("\"contractStartDate\":\"").append(dto.contractStartDate != null ? dto.contractStartDate : "").append("\",");
            json.append("\"contractEndDate\":\"").append(dto.contractEndDate != null ? dto.contractEndDate : "").append("\",");
            json.append("\"signDate\":\"").append(dto.signDate != null ? dto.signDate : "").append("\",");
            json.append("\"deposit\":").append(dto.deposit != null ? dto.deposit : "null").append(",");
            json.append("\"nursingFee\":").append(dto.nursingFee != null ? dto.nursingFee : "null").append(",");
            json.append("\"bedFee\":").append(dto.bedFee != null ? dto.bedFee : "null").append(",");
            json.append("\"otherFee\":").append(dto.otherFee != null ? dto.otherFee : "null").append(",");
            json.append("\"partyCName\":\"").append(dto.partyCName != null ? dto.partyCName : "").append("\",");
            json.append("\"partyCPhone\":\"").append(dto.partyCPhone != null ? dto.partyCPhone : "").append("\",");
            json.append("\"contractFile\":\"").append(dto.contractFile != null ? dto.contractFile : "").append("\"");
            json.append("}");
            return json.toString();
        } catch (Exception e) {
            System.out.println("转换DTO为JSON失败: " + e.getMessage());
            return "{}";
        }
    }
    
    /**
     * 完成签约办理 - 保存完整的入住管理和合同数据
     * 在签约办理步骤完成时调用此方法
     * 
     * @param checkInManagementId 入住管理ID
     * @param dto 完整的入住数据
     */
    @Transactional(rollbackFor = Exception.class)
    public void finalizeCheckInContract(Long checkInManagementId, CheckInWorkflowDTO dto) {
        try {
            System.out.println("开始完成签约办理，入住管理ID: " + checkInManagementId);
            
            // 1. 更新入住管理表的完整信息
            CheckInManagement checkInManagement = checkInManagementMapper.selectCheckInManagementById(checkInManagementId);
            if (checkInManagement == null) {
                throw new RuntimeException("入住管理记录不存在，ID: " + checkInManagementId);
            }
            
            // 设置入住单号（如果有）
            if (dto.contractNo != null && !dto.contractNo.trim().isEmpty()) {
                checkInManagement.setCheckInNo(dto.contractNo);
            } else {
                // 自动生成入住单号
                checkInManagement.setCheckInNo("RZ-" + checkInManagementId);
            }
            
            // 设置入住时间
            checkInManagement.setCheckInStartTime(dto.checkInStartTime);
            checkInManagement.setCheckInEndTime(dto.checkInEndTime);
            
            // 设置护理等级
            checkInManagement.setNursingLevelId(dto.nursingLevelId);
            
            // 设置床位
            checkInManagement.setBedId(dto.bedId);
            
            // 设置费用期限
            checkInManagement.setFeeStartDate(dto.feeStartDate);
            checkInManagement.setFeeEndDate(dto.feeEndDate);
            
            // 设置费用信息
            checkInManagement.setDeposit(dto.deposit);
            checkInManagement.setNursingFee(dto.nursingFee);
            checkInManagement.setBedFee(dto.bedFee);
            checkInManagement.setOtherFee(dto.otherFee);
            checkInManagement.setMedicalInsurancePayment(dto.medicalInsurancePayment);
            checkInManagement.setGovernmentSubsidy(dto.governmentSubsidy);
            
            // 设置合同状态
            checkInManagement.setContractStatus("已入住");
            
            // 更新入住管理记录
            checkInManagementMapper.updateCheckInManagement(checkInManagement);
            System.out.println("入住管理信息更新成功");
            
            // 2. 插入合同表
            Contract contract = new Contract();
            contract.setContractNo(dto.contractNo != null ? dto.contractNo : ("HT-" + checkInManagementId));
            contract.setContractName(dto.contractName);
            contract.setElderlyId(checkInManagement.getElderlyId());
            contract.setStartDate(dto.contractStartDate);
            contract.setEndDate(dto.contractEndDate);
            contract.setSignTime(dto.signDate);
            contract.setPartyCName(dto.partyCName);
            contract.setPartyCPhone(dto.partyCPhone);
            contract.setContractFile(dto.contractFile);
            contract.setCheckInManagementId(checkInManagementId);
            contract.setContractStatus("已签约");
            contract.setCreateTime(DateUtils.getNowDate());
            contractMapper.insertContract(contract);
            System.out.println("合同信息插入成功");
            
            // 3. 插入家人表（如果有家人信息）
            Long elderlyId = checkInManagement.getElderlyId();
            if (dto.familyMembers != null && !dto.familyMembers.isEmpty()) {
                // 处理家属信息列表
                for (CheckInWorkflowDTO.FamilyMemberDTO familyDto : dto.familyMembers) {
                    if (familyDto.name != null && !familyDto.name.trim().isEmpty()) {
                        FamilyMember familyMember = new FamilyMember();
                        familyMember.setName(familyDto.name);
                        familyMember.setContact(familyDto.contact);
                        familyMember.setRelationship(familyDto.relationship);
                        familyMember.setElderlyId(elderlyId);
                        familyMember.setCreateTime(DateUtils.getNowDate());
                        familyMember.setIsDeleted(0L);
                        familyMemberMapper.insertFamilyMember(familyMember);
                        System.out.println("插入家属信息: " + familyMember.getName());
                    }
                }
            } else if (dto.partyCName != null && !dto.partyCName.trim().isEmpty()) {
                // 兼容旧版本：如果没有提供家属列表，使用合同甲方信息创建默认家属
                FamilyMember familyMember = new FamilyMember();
                familyMember.setName(dto.partyCName);
                familyMember.setContact(dto.partyCPhone);
                familyMember.setRelationship("家属"); // 默认关系
                familyMember.setElderlyId(elderlyId);
                familyMember.setCreateTime(DateUtils.getNowDate());
                familyMember.setIsDeleted(0L);
                familyMemberMapper.insertFamilyMember(familyMember);
                System.out.println("插入默认家属信息: " + familyMember.getName());
            }
            
            // 4. 更新床位状态为已占用
            if (dto.bedId != null) {
                Bed bed = bedMapper.selectBedById(dto.bedId);
                if (bed != null) {
                    bed.setStatus(1L); // 1:已占用
                    bed.setUpdateTime(DateUtils.getNowDate());
                    bedMapper.updateBed(bed);
                    System.out.println("床位状态更新为已占用");
                }
            }
            
            // 5. 生成首期缴费账单
            try {
                System.out.println("开始生成首期缴费账单，老人ID: " + elderlyId);
                int billResult = billService.generateFirstBill(elderlyId);
                if (billResult > 0) {
                    System.out.println("首期缴费账单生成成功");
                } else {
                    System.out.println("首期账单可能已存在，未重复生成");
                }
            } catch (Exception billEx) {
                System.err.println("生成首期账单失败: " + billEx.getMessage());
                // 不影响主流程，仅记录日志
            }
            
            System.out.println("签约办理完成，所有数据保存成功");
            
        } catch (Exception e) {
            System.out.println("完成签约办理失败: " + e.getMessage());
            e.printStackTrace();
            throw new RuntimeException("完成签约办理失败: " + e.getMessage(), e);
        }
    }
    
    /**
     * 根据业务ID获取当前活动的Activiti任务ID
     * 用于解决pending_tasks表中taskId为空的问题
     * 
     * @param businessId 业务ID（入住管理ID）
     * @return Activiti任务ID，如果没有活动任务则返回null
     */
    @Override
    public String getCurrentActivitiTaskId(Long businessId) {
        try {
            System.out.println("========== 查询当前活动任务ID ==========");
            System.out.println("业务ID: " + businessId);
            
            // 查询当前活动的任务
            List<Task> activeTasks = taskService.createTaskQuery()
                .processInstanceBusinessKey(businessId.toString())
                .processDefinitionKey("checkin")
                .list();
            
            System.out.println("查询到活动任务数量: " + (activeTasks != null ? activeTasks.size() : 0));
            
            if (activeTasks != null && !activeTasks.isEmpty()) {
                // 返回第一个活动任务的ID
                Task activeTask = activeTasks.get(0);
                System.out.println("活动任务ID: " + activeTask.getId());
                System.out.println("任务名称: " + activeTask.getName());
                return activeTask.getId();
            } else {
                System.out.println("未找到活动的工作流任务");
                return null;
            }
        } catch (Exception e) {
            System.err.println("查询活动任务失败: " + e.getMessage());
            e.printStackTrace();
            return null;
        }
    }
}
